home *** CD-ROM | disk | FTP | other *** search
/ SGI Freeware 2002 November / SGI Freeware 2002 November - Disc 2.iso / dist / fw_libgtop.idb / usr / freeware / info / libgtop.info.z / libgtop.info
Text File  |  2002-07-08  |  58KB  |  2,005 lines
  1. This is libgtop.info, produced by makeinfo version 4.0 from
  2. libgtop.texi.
  3.  
  4.    This is the LibGTop Reference Manual version 1.0.12 (last modified
  5. 16 May 1999).
  6.  
  7.    Copyright 1999 Free Software Foundation, Inc.
  8.  
  9.    Permission is granted to make and distribute verbatim copies of this
  10. manual provided the copyright notice and this permission notice are
  11. preserved on all copies.
  12.  
  13.    Permission is granted to copy and distribute modified versions of
  14. this manual under the conditions for verbatim copying, provided also
  15. that the sections entitled "Copying" and "GNU General Public License"
  16. are included exactly as in the original, and provided that the entire
  17. resulting derived work is distributed under the terms of a permission
  18. notice identical to this one.
  19.  
  20.    Permission is granted to copy and distribute translations of this
  21. manual into another language, under the above conditions for modified
  22. versions, except that this permission notice may be stated in a
  23. translation approved by the Free Software Foundation.
  24.  
  25. 
  26. File: libgtop.info,  Node: Top,  Next: About,  Prev: (dir),  Up: (dir)
  27.  
  28. * Menu:
  29.  
  30. * About::                       About LibGTop
  31. * White Paper::                 LibGTop White Paper
  32. * Reference Manual::            LibGTop Reference Manual
  33.  
  34.  --- The Detailed Node Listing ---
  35.  
  36. About LibGTop
  37.  
  38. * Availability::                Where to get LibGTop
  39. * Supported Platforms::         Supported Platforms
  40. * Mailing List::                Helping with LibGTop development
  41. * Thanks::                      People who contributed to LibGTop
  42.  
  43. LibGTop White Paper
  44.  
  45. * Introduction::                Introduction
  46. * Overview::                    Overview
  47.  
  48. Overview
  49.  
  50. * Interface Design::            Things that need to be considered
  51. * Server Implementation::       The LibGTop "server"
  52.  
  53. LibGTop Reference Manual
  54.  
  55. * System Dependent::            System Dependent Functions.
  56. * Common Functions::            Common Functions.
  57. * Library Functions::           Library Functions.
  58.  
  59. System Dependent Functions
  60.  
  61. * glibtop_cpu::                 CPU Usage.
  62. * glibtop_mem::                 Memory Usage.
  63. * glibtop_swap::                Swap Usage.
  64. * glibtop_uptime::              System Uptime.
  65. * glibtop_loadavg::             Load Average.
  66. * glibtop_proclist::            Process List.
  67. * glibtop_proc_state::          Process State.
  68. * glibtop_proc_uid::            Process UID and TTY Information.
  69. * glibtop_proc_mem::            Process Memory Information.
  70. * glibtop_proc_time::           Process Time Information.
  71. * glibtop_proc_signal::         Process Signal Information.
  72. * glibtop_proc_kernel::         Process Kernel Data Information.
  73. * glibtop_proc_segment::        Process Segment Information.
  74. * glibtop_proc_args::           Process Arguments.
  75. * glibtop_proc_map::            Process Memory Maps.
  76. * glibtop_netload::             Network Load.
  77. * glibtop_ppp::                 PPP Usage.
  78.  
  79. Common Functions
  80.  
  81. * glibtop_mountlist::           Mount List.
  82. * glibtop_fsusage::             File System Usage.
  83.  
  84. Library Functions
  85.  
  86. * glibtop_init::                Server Initialization.
  87. * glibtop_sysdeps::             Server Sysdeps.
  88. * Library Parameters::          Library Parameters.
  89.  
  90. 
  91. File: libgtop.info,  Node: About,  Next: White Paper,  Prev: Top,  Up: Top
  92.  
  93. About LibGTop
  94. *************
  95.  
  96.    LibGTop is a library to get system specific data such as CPU and
  97. Memory Usage and information about running Processes.
  98.  
  99.    On Systems like Solaris or Digital Unix where you need special
  100. privileges to get those data, it uses a setuid/setgid server to do so.
  101.  
  102.    Even if LibGTop is a part of the GNOME desktop environment
  103. (`http://www.gnome.org'), the main interface of LibGTop is totally
  104. independent from any particular desktop environment, so you can also
  105. use it as a standalone library in any piece of GPLed software.
  106.  
  107. * Menu:
  108.  
  109. * Availability::                Where to get LibGTop
  110. * Supported Platforms::         Supported Platforms
  111. * Mailing List::                Helping with LibGTop development
  112. * Thanks::                      People who contributed to LibGTop
  113.  
  114. 
  115. File: libgtop.info,  Node: Availability,  Next: Supported Platforms,  Prev: About,  Up: About
  116.  
  117. Availability
  118. ============
  119.  
  120.    The master source of LibGTop is the GNOME CVS tree (see
  121. `http://www.gnome.org' for details), but you can also get the latest
  122. release tarballs from
  123.  
  124.      `ftp://ftp.gnome.org/pub/GNOME/sources/libgtop/'
  125.  
  126. or any of its mirror sites.
  127.  
  128.    The latest stable version of LibGTop is 1.0.1 which is also the one
  129. that comes together with GNOME 1.0. In CVS, there is a
  130. `LIBGTOP_STABLE_1_0' branch which is rooted at the `LIBGTOP_1_0_1' tag
  131. while actual development occurs in the `HEAD' which currently has
  132. version 1.1.0.
  133.  
  134. 
  135. File: libgtop.info,  Node: Supported Platforms,  Next: Mailing List,  Prev: Availability,  Up: About
  136.  
  137. Supported Platforms
  138. ===================
  139.  
  140.    The stable branch currently supports the following platforms:
  141.  
  142.    * All versions of Linux
  143.  
  144.      LibGTop was tested under Linux 2.0.x and 2.2.x on the ix86 and the
  145.      alpha, but it should also work without problems on SparcLinux.
  146.  
  147.      Note: I'm speaking of the Linux kernel here, not the GNU/Linux
  148.      operating system.
  149.  
  150.    * FreeBSD, NetBSD and OpenBSD
  151.  
  152.      LibGTop was tested under FreeBSD 2.2.6 and 3.0, NetBSD 1.3.2 and
  153.      OpenBSD 2.4.  Support for NetBSD 1.4 was added in LibGTop 1.0.2.
  154.  
  155.  
  156.    The platforms listed above are known to be stable and working.
  157. However, if you're using the latest development version, you can use it
  158. on the following platforms as well:
  159.  
  160.    * BSD/OS
  161.  
  162.      There is a port for BSD/OS (aka BSDI) 2.x and 3.x from Timur
  163.      Bakeyev which should also work with 4.x. This isn't tested very
  164.      well, but it should be working.
  165.  
  166.    * Digital Unix
  167.  
  168.      There is some basic support for Digital Unix (formerly DEC OSF/1)
  169.      V3.2C, but this may still be a bit unstable. I'm currently working
  170.      on this port as time permits so it should be fully supported soon.
  171.  
  172.    * Solaris
  173.  
  174.      The Solaris port currently works on Solaris 7 and maybe also on
  175.      other releases.  Thanks a lot to Drazen Kacar and everyone who
  176.      helped working on this port. They have really done excellent work
  177.      here and I'm pretty sure that this port will be fully functional
  178.      on most Solaris versions in near future.
  179.  
  180.  
  181. 
  182. File: libgtop.info,  Node: Mailing List,  Next: Thanks,  Prev: Supported Platforms,  Up: About
  183.  
  184. Mailing List
  185. ============
  186.  
  187.    There is a <libgtop-devel-list@egroups.com> mailing list for people
  188. who want to help with the development of LibGTop.
  189.  
  190.    It is meant as a low-traffic, but high content-list where we can
  191. discuss technical details such as adding new sysdeps ports etc.
  192.  
  193.    Especially, I'd like to see people with a deeper knowledge of
  194. operating systems internals joining my list so we can discuss technical
  195. details of the sysdeps code.
  196.  
  197.    It is *not* for users that want to know how to compile LibGTop etc.
  198.  
  199.    You can subscribe to this mailing list and view the mailing list
  200. archives on the LibGTop Page at
  201. `http://www.home-of-linux.org/gnome/libgtop'.
  202.  
  203. 
  204. File: libgtop.info,  Node: Thanks,  Prev: Mailing List,  Up: About
  205.  
  206. Thanks
  207. ======
  208.  
  209.    At the place I'd like to thank the following people who contributed
  210. to LibGTop (listed in chronological order):
  211.  
  212.    * Sebastian Wilhelmi who had the initial idea of LibGTop and helped
  213.      me a lot in the early beginning.
  214.  
  215.    * Josh Sled for the initial FreeBSD port.
  216.  
  217.    * Jeremy Lea for his BSD patches.
  218.  
  219.    * Timur Bakeyev for the BSDI port.
  220.  
  221.    * Drazen Kacar and the other people on the LibGTop development
  222.      mailing list for the Solaris port.
  223.  
  224.    * All people sending me patches, having good ideas, ...
  225.  
  226.    * Everyone I have forgotten in this list ...
  227.  
  228. 
  229. File: libgtop.info,  Node: White Paper,  Next: Reference Manual,  Prev: About,  Up: Top
  230.  
  231. LibGTop White Paper
  232. *******************
  233.  
  234. * Menu:
  235.  
  236. * Introduction::                Introduction
  237. * Overview::                    Overview
  238.  
  239. 
  240. File: libgtop.info,  Node: Introduction,  Next: Overview,  Prev: White Paper,  Up: White Paper
  241.  
  242. Introduction
  243. ============
  244.  
  245.    Many modern UNIX systems like Solaris, BSD or Digitial Unix only
  246. allow priviledged processes to read information like CPU and Memory
  247. Usage or information about running processes.
  248.  
  249.    * BSD, for instance, doesn't have any other way to get those data
  250.      than reading directly from `/dev/kmem' and you need to be in the
  251.      `kmem' group to be able to read this.
  252.  
  253.    * Other systems, like Digital Unix, allow all users to get things
  254.      like CPU and Memory statistics, but only root may read information
  255.      about any process other than the current one (you may not even get
  256.      information about your own processes if you're not root).
  257.  
  258.    * Linux has a very nice `/proc' filesystem, but reading and parsing
  259.      `/proc' is very slow and inefficient.
  260.  
  261.    * Solaris is a bit better, but you still need to be in the `sys'
  262.      group or even root to get some data.
  263.  
  264.    Because of this system utilities like `ps', `uptime' or `top' often
  265. are setgid kmem or setuid root. Usually, they're also very specific to
  266. the system they're written for and not easily portable to other systems
  267. without a lot of work.
  268.  
  269.    This, of cause, becomes a problem for graphical tools like `gtop' -
  270. making a GTK+ program setgid or even setuid would be a security hole as
  271. big as you can drive the entire X11 source code through. For the GNOME
  272. project, we also needed some kind of library which provides all the
  273. required information in a portable since there's more than just one
  274. single program that wants to use them - for instance `gtop' and the
  275. `multiload', `cpumemusage' and `netload' panel applets.
  276.  
  277. 
  278. File: libgtop.info,  Node: Overview,  Prev: Introduction,  Up: White Paper
  279.  
  280. Overview
  281. ========
  282.  
  283.    This section should give you a short overview on how LibGTop was
  284. developed, which things needed to be considered and how it works.
  285.  
  286. * Menu:
  287.  
  288. * Interface Design::            Things that need to be considered
  289. * Server Implementation::       The LibGTop "server"
  290.  
  291. 
  292. File: libgtop.info,  Node: Interface Design,  Next: Server Implementation,  Prev: Overview,  Up: Overview
  293.  
  294. Interface Design
  295. ----------------
  296.  
  297.    At the very beginning, it was necessary to collect all the data the
  298. library part should provide and put them into some C structures. This
  299. was not that easiy as it might sound since LibGTop should be portable
  300. to any modern UNIX system with a common library part on all those
  301. systems, but the data that should be returned vary from system to
  302. system. For instance some systems support shared memory, but some others
  303. may not.
  304.  
  305.    The header files where we define these C structures (which are
  306. system-independent) are shared between client and server. This way we
  307. can call the system dependent code directly where we do not need any
  308. special privileges to do so.
  309.  
  310.    All of those structures contain a `flags' member which is
  311. interpreted as a bit mask and tells the caller of the library functions
  312. which of the fields in the returned structure are valid and which are
  313. not.
  314.  
  315. 
  316. File: libgtop.info,  Node: Server Implementation,  Prev: Interface Design,  Up: Overview
  317.  
  318. Server Implementation
  319. ---------------------
  320.  
  321.    The LibGTop "server" is a setgid/setuid binary which contains all
  322. the system dependent code which needs special privileges. It is only
  323. build if it's required on the current system (for instance, the Linux
  324. kernel provides all the required data via its `/proc' filesystem so we
  325. do not need the server at all) and it only contains the "features"
  326. which need privileges.
  327.  
  328.    Whenever we do not need any privileges to get all the data for some
  329. of the requested structures (here called "features") the library calls
  330. the sysdeps code directly rather than using the server.
  331.  
  332. 
  333. File: libgtop.info,  Node: Reference Manual,  Prev: White Paper,  Up: Top
  334.  
  335. LibGTop Reference Manual
  336. ************************
  337.  
  338. * Menu:
  339.  
  340. * System Dependent::            System Dependent Functions.
  341. * Common Functions::            Common Functions.
  342. * Library Functions::           Library Functions.
  343.  
  344. 
  345. File: libgtop.info,  Node: System Dependent,  Next: Common Functions,  Prev: Reference Manual,  Up: Reference Manual
  346.  
  347. System Dependent Functions
  348. ==========================
  349.  
  350. * Menu:
  351.  
  352. * glibtop_cpu::                 CPU Usage.
  353. * glibtop_mem::                 Memory Usage.
  354. * glibtop_swap::                Swap Usage.
  355. * glibtop_uptime::              System Uptime.
  356. * glibtop_loadavg::             Load Average.
  357. * glibtop_proclist::            Process List.
  358. * glibtop_proc_state::          Process State.
  359. * glibtop_proc_uid::            Process UID and TTY Information.
  360. * glibtop_proc_mem::            Process Memory Information.
  361. * glibtop_proc_time::           Process Time Information.
  362. * glibtop_proc_signal::         Process Signal Information.
  363. * glibtop_proc_kernel::         Process Kernel Data Information.
  364. * glibtop_proc_segment::        Process Segment Information.
  365. * glibtop_proc_args::           Process Arguments.
  366. * glibtop_proc_map::            Process Memory Maps.
  367. * glibtop_netload::             Network Load.
  368. * glibtop_ppp::                 PPP Usage.
  369.  
  370. 
  371. File: libgtop.info,  Node: glibtop_cpu,  Next: glibtop_mem,  Prev: System Dependent,  Up: System Dependent
  372.  
  373. CPU Usage
  374. ---------
  375.  
  376.    Library function `glibtop_get_cpu':
  377.  
  378.      void glibtop_get_cpu (glibtop_cpu *buf);
  379.      void glibtop_get_cpu_l (glibtop *server, glibtop_cpu *buf);
  380.  
  381.    Declaration of `glibtop_cpu' in `<glibtop/cpu.h>':
  382.  
  383.      typedef struct _glibtop_cpu     glibtop_cpu;
  384.      
  385.      struct _glibtop_cpu
  386.      {
  387.          u_int64_t   flags,
  388.              total,
  389.              user,
  390.              nice,
  391.              sys,
  392.              idle,
  393.              frequency,
  394.              xcpu_total [GLIBTOP_NCPU],
  395.              xcpu_user [GLIBTOP_NCPU],
  396.              xcpu_nice [GLIBTOP_NCPU],
  397.              xcpu_sys  [GLIBTOP_NCPU],
  398.              xcpu_idle [GLIBTOP_NCPU];
  399.      };
  400.  
  401.    All CPU units are measured in "jiffies" which are normally 1/100th
  402. of a second (in which case `frequency' equals 100), but can also be in
  403. any other unit. To get seconds, divide them by `frequency'.
  404.  
  405. `total'
  406.      Number of clock ticks since system boot.
  407.  
  408. `user'
  409.      Number of clock ticks the system spent in user mode.
  410.  
  411. `nice'
  412.      Number of clock ticks the system spent in user mode (nice).
  413.  
  414. `sys'
  415.      Number of clock ticks the system spent in system mode.
  416.  
  417. `idle'
  418.      Number of clock ticks the system spent in the idle task.
  419.  
  420. `frequency'
  421.      Tick frequency (default is 100).
  422.  
  423.    The `xcpu_' values are for SMP systems - they are the same than
  424. `total', `user', `nice', `sys' and `idle' except that they are arrays
  425. of `GLIBTOP_NCPU' (defined in `<glibtop/limits.h>') elements and
  426. contain one value for each CPU in the system.
  427.  
  428.    Please note that all of the cpu values are absolute values measured
  429. in certain units (to get seconds, divide them by `frequency') since
  430. system boot. To get percentual values, you need to call `glibtop_cpu',
  431. save the result, wait some time and then call it again and divide the
  432. differences of the two values by the time you have waited.
  433.  
  434. 
  435. File: libgtop.info,  Node: glibtop_mem,  Next: glibtop_swap,  Prev: glibtop_cpu,  Up: System Dependent
  436.  
  437. Memory Usage
  438. ------------
  439.  
  440.    Library function `glibtop_get_mem':
  441.  
  442.      void glibtop_get_mem (glibtop_mem *buf);
  443.      void glibtop_get_mem_l (glibtop *server, glibtop_mem *buf);
  444.  
  445.    Declaration of `glibtop_mem' in `<glibtop/mem.h>':
  446.  
  447.      typedef struct _glibtop_mem     glibtop_mem;
  448.      
  449.      struct _glibtop_mem
  450.      {
  451.          u_int64_t   flags,
  452.              total,
  453.              used,
  454.              free,
  455.              shared,
  456.              buffer,
  457.              cached,
  458.              user,
  459.              locked;
  460.      };
  461.  
  462.    Unless explicitly stated otherwise, all memory units are in bytes.
  463.  
  464. `total'
  465.      Total physical memory.
  466.  
  467. `used'
  468.      Used memory size.
  469.  
  470. `free'
  471.      Free memory size.
  472.  
  473. `shared'
  474.      Shared memory size.
  475.  
  476.      This are both segments that are `mmap()'ed with `MAP_SHARED' and
  477.      IPC Shared Memory segments.
  478.  
  479. `buffer'
  480.      Size of buffers.
  481.  
  482. `cached'
  483.      Size of cached memory.
  484.  
  485. `user'
  486.      Memory used from user processes.
  487.  
  488.      This is normally `total - free - shared - buffer - cached'.
  489.  
  490. `locked'
  491.      Memory in locked segments.
  492.  
  493. 
  494. File: libgtop.info,  Node: glibtop_swap,  Next: glibtop_uptime,  Prev: glibtop_mem,  Up: System Dependent
  495.  
  496. Swap Usage
  497. ----------
  498.  
  499.    Library function `glibtop_get_swap':
  500.  
  501.      void glibtop_get_swap (glibtop_swap *buf);
  502.      void glibtop_get_swap_l (glibtop *server, glibtop_swap *buf);
  503.  
  504.    Declaration of `glibtop_swap' in `<glibtop/swap.h>':
  505.  
  506.      typedef struct _glibtop_swap    glibtop_swap;
  507.      
  508.      struct _glibtop_swap
  509.      {
  510.          u_int64_t   flags,
  511.              total,
  512.              used,
  513.              free,
  514.              pagein,
  515.              pageout;
  516.      };
  517.  
  518.    The following units are in bytes.
  519.  
  520. `total'
  521.      Total swap space in the system.
  522.  
  523. `used'
  524.      Used swap space.
  525.  
  526. `free'
  527.      Free swap space.
  528.  
  529.    You can use `pagein' and `pageout' to get some measure about how
  530. much the system is swapping at the moment. They're increased each time
  531. a page is swapped in or out, so you need to save this values, wait a
  532. little bit, get them again and then compare the two results to find out
  533. how much the system swapped in the meantime.
  534.  
  535. `pagein'
  536.      Total number of swap pages that have been brought in since system
  537.      boot
  538.  
  539. `pageout'
  540.      Total number of swap pages that have been brought out since system
  541.      boot
  542.  
  543. 
  544. File: libgtop.info,  Node: glibtop_uptime,  Next: glibtop_loadavg,  Prev: glibtop_swap,  Up: System Dependent
  545.  
  546. Uptime
  547. ------
  548.  
  549.    Library function `glibtop_get_uptime':
  550.  
  551.      void glibtop_get_uptime (glibtop_uptime *buf);
  552.      void glibtop_get_uptime_l (glibtop *server, glibtop_uptime *buf);
  553.  
  554.    Declaration of `glibtop_uptime' in `<glibtop/uptime.h>':
  555.  
  556.      typedef struct _glibtop_uptime  glibtop_uptime;
  557.      
  558.      struct _glibtop_uptime
  559.      {
  560.          u_int64_t flags;
  561.          double uptime,
  562.              idletime;
  563.          u_int64_t boot_time;
  564.      };
  565.  
  566.    When porting LibGTop to a new system, you only need to implement
  567. `uptime' and `idletime' if there's a faster or better way to obtain
  568. them as using `glibtop_cpu' for it. Look at `sysdeps/freebsd/uptime.c'
  569. for an example on how to obtain them using `glibtop_cpu'.
  570.  
  571. `uptime'
  572.      Time in seconds since system boot.
  573.  
  574. `idletime'
  575.      Time in seconds the system spent in the idle task since system
  576.      boot.
  577.  
  578.    The following one was from a request on the `linux-kernel' mailing
  579. list; on a laptop with advanced power management `glibtop_cpu.total'
  580. may not reflect the correct boot time of the system if the power was
  581. turned off by means of APM in the meantime.
  582.  
  583. `boot_time'
  584.      Time of last system boot in seconds since the epoch.
  585.  
  586. 
  587. File: libgtop.info,  Node: glibtop_loadavg,  Next: glibtop_proclist,  Prev: glibtop_uptime,  Up: System Dependent
  588.  
  589. Load Average
  590. ------------
  591.  
  592.    Library function `glibtop_get_loadavg':
  593.  
  594.      void glibtop_get_loadavg (glibtop_loadavg *buf);
  595.      void glibtop_get_loadavg_l (glibtop *server, glibtop_loadavg *buf);
  596.  
  597.    Declaration of `glibtop_loadavg' in `<glibtop/loadavg.h>':
  598.  
  599.      typedef struct _glibtop_loadavg glibtop_loadavg;
  600.      
  601.      struct _glibtop_loadavg
  602.      {
  603.          u_int64_t flags;
  604.          double loadavg [3];
  605.          u_int64_t nr_running,
  606.              nr_tasks,
  607.              last_pid;
  608.      };
  609.  
  610. `loadavg'
  611.      Number of jobs running simultaneously averaged over 1, 5 and 15
  612.      minutes.
  613.  
  614.    The following fields are Linux specific and deprecated. You don't
  615. need to implement them when porting LibGTop to a new system as they may
  616. be removed in a future version.
  617.  
  618. `nr_running'
  619.      Number of tasks currently running.
  620.  
  621. `nr_tasks'
  622.      Total number of tasks.
  623.  
  624. `last_pid'
  625.      Last PID.
  626.  
  627. 
  628. File: libgtop.info,  Node: glibtop_proclist,  Next: glibtop_proc_state,  Prev: glibtop_loadavg,  Up: System Dependent
  629.  
  630. Process List
  631. ------------
  632.  
  633.    Library function `glibtop_get_proclist':
  634.  
  635.      unsigned *
  636.      glibtop_get_proclist (glibtop_proclist *buf,
  637.                            int64_t which, int64_t arg);
  638.      
  639.      unsigned *
  640.      glibtop_get_proclist_l (glibtop *server, glibtop_proclist *buf,
  641.                              int64_t which, int64_t arg);
  642.  
  643.    Constants for the `which' argument:
  644.  
  645.      #define GLIBTOP_KERN_PROC_ALL           0
  646.      #define GLIBTOP_KERN_PROC_PID           1
  647.      #define GLIBTOP_KERN_PROC_PGRP          2
  648.      #define GLIBTOP_KERN_PROC_SESSION       3
  649.      #define GLIBTOP_KERN_PROC_TTY           4
  650.      #define GLIBTOP_KERN_PROC_UID           5
  651.      #define GLIBTOP_KERN_PROC_RUID          6
  652.      
  653.      #define GLIBTOP_KERN_PROC_MASK          15
  654.      
  655.      #define GLIBTOP_EXCLUDE_IDLE            0x1000
  656.      #define GLIBTOP_EXCLUDE_SYSTEM          0x2000
  657.      #define GLIBTOP_EXCLUDE_NOTTY           0x4000
  658.  
  659.    Declaration of `glibtop_proclist' in `<glibtop/proclist.h>':
  660.  
  661.      typedef struct _glibtop_proclist        glibtop_proclist;
  662.      
  663.      struct _glibtop_proclist
  664.      {
  665.          u_int64_t   flags,
  666.              number,
  667.              total,
  668.              size;
  669.      };
  670.  
  671.    This function returns a list of all or a selected subset of all
  672. running processes. You can use the `which' and `arg' arguments to
  673. specify which processes should be returned.
  674.  
  675.    You can use the following values for the `which' argument:
  676.  
  677. `GLIBTOP_KERN_PROC_ALL'
  678.      Return information about all processes (the `arg' argument is
  679.      ignored).
  680.  
  681. `GLIBTOP_KERN_PROC_PID'
  682.      Return information about all process with the pid PID which is
  683.      passed in `arg'. You can use this to find out whether some process
  684.      still exists.
  685.  
  686. `GLIBTOP_KERN_PROC_PGRP'
  687.      Return all processes in process group PGRP which is passed in
  688.      `arg'.
  689.  
  690. `GLIBTOP_KERN_PROC_SESSION'
  691.      Return all processes in session SESSION which is passed in `arg'.
  692.  
  693. `GLIBTOP_KERN_PROC_TTY'
  694.      Return all processes which have the controlling tty TTY which is
  695.      passed in `arg' (TTY is interpreted as device number).
  696.  
  697. `GLIBTOP_KERN_PROC_UID'
  698.      Return all processes with effective uid UID which is passed in
  699.      `arg'.
  700.  
  701. `GLIBTOP_KERN_PROC_RUID'
  702.      Return all processes with real uid RUID which is passed in `arg'.
  703.  
  704.    You can alter the list of returned processes by using a binary OR of
  705. `which' and the following constants:
  706.  
  707. `GLIBTOP_EXCLUDE_IDLE'
  708.      Exclude idle processes.
  709.  
  710. `GLIBTOP_EXCLUDE_SYSTEM'
  711.      Exclude system processes.
  712.  
  713. `GLIBTOP_EXCLUDE_NOTTY'
  714.      Exclude processes without a controlling terminal.
  715.  
  716.    The return value of `glibtop_get_proclist' is either `NULL' on error
  717. or a `unsigned *' list of pids. Additionally, the following fields of
  718. `glibtop_proclist' are set:
  719.  
  720. `number'
  721.      Number of entries in the returned list.
  722.  
  723. `total'
  724.      Total size of the returned list (this equals `number * size').
  725.  
  726. `size'
  727.      Size of a single entry in the returned list (this equals `sizeof
  728.      (unsigned)').
  729.  
  730.    The returned list is allocated using `glibtop_malloc' and must be
  731. freed using `glibtop_free' to avoid a memory leak.
  732.  
  733. 
  734. File: libgtop.info,  Node: glibtop_proc_state,  Next: glibtop_proc_uid,  Prev: glibtop_proclist,  Up: System Dependent
  735.  
  736. Process State
  737. -------------
  738.  
  739.    Library function `glibtop_get_proc_state':
  740.  
  741.      void
  742.      glibtop_get_proc_state (glibtop_proc_state *buf, pid_t pid);
  743.      
  744.      void
  745.      glibtop_get_proc_state_l (glibtop *server, glibtop_proc_state *buf,
  746.                                pid_t pid);
  747.  
  748.    Declaration of `glibtop_proc_state' in `<glibtop/proc_state.h>':
  749.  
  750.      typedef struct _glibtop_proc_state      glibtop_proc_state;
  751.      
  752.      struct _glibtop_proc_state
  753.      {
  754.          u_int64_t flags;
  755.          char cmd[40];
  756.          char state;
  757.          int uid,
  758.              gid,
  759.              ruid,
  760.              rgid;
  761.          int has_cpu,
  762.              processor,
  763.              last_processor;
  764.      
  765.      };
  766.  
  767. `cmd'
  768.      Basename of the executable file in the call to `exec'.
  769.  
  770. `state'
  771.      Process state ('R' = running, 'S' = sleeping, 'D' =
  772.      uninterruptible, 'Z' = zombie, 'T' = stopped, 'I' = idle).
  773.  
  774.      This was changed to an `unsigned' bitfield in LibGTop 1.1.x where
  775.      there are also some constants for it.
  776.  
  777.    When porting LibGTop, please _try hard_ to implement the following
  778. fields. For security reasons, it is *very important* that you *only*
  779. set the `flags' bits for those fields if their *values are correct*.
  780.  
  781. `uid'
  782.      Effective UID of the process.
  783.  
  784. `gid'
  785.      Effective GID of the process.
  786.  
  787. `ruid'
  788.      Real UID of the process.
  789.  
  790. `rgid'
  791.      Read GID of the process.
  792.  
  793.    The following fields are for SMP systems:
  794.  
  795. `has_cpu'
  796.      This is either 0 or 1 depending on whether the process currently
  797.      has a CPU or not.
  798.  
  799. `processor'
  800.      This is the processor id of the CPU this process is currently
  801.      running on (which can be used as index in the `xcpu_' fields of
  802.      `glibtop_cpu' for instance; since zero is a valid processor id,
  803.      you must check `has_cpu' in this case to find out whether the
  804.      process really has a CPU).
  805.  
  806. `last_processor'
  807.      The is the processor id of the CPU the process was last running on.
  808.  
  809. `GLIBTOP_PROCESS_RUNNING'
  810.      The process is currently running.
  811.  
  812. `GLIBTOP_PROCESS_INTERRUPTIBLE'
  813.      The process is currently in an interruptible sleep.
  814.  
  815. `GLIBTOP_PROCESS_UNINTERRUPTIBLE'
  816.      The process is currently in uninterruptible sleep (the so-called
  817.      "disk sleep").
  818.  
  819. `GLIBTOP_PROCESS_ZOMBIE'
  820.      The process is a zombie.
  821.  
  822. `GLIBTOP_PROCESS_STOPPED'
  823.      The process is currently stopped (received `SIGSTOP' or attached
  824.      to a debugger).
  825.  
  826. `GLIBTOP_PROCESS_SWAPPING'
  827.      The process is currently swapping.
  828.  
  829. 
  830. File: libgtop.info,  Node: glibtop_proc_uid,  Next: glibtop_proc_mem,  Prev: glibtop_proc_state,  Up: System Dependent
  831.  
  832. Process UID and TTY information
  833. -------------------------------
  834.  
  835.    Library function `glibtop_get_proc_uid':
  836.  
  837.      void
  838.      glibtop_get_proc_uid (glibtop_proc_uid *buf, pid_t pid);
  839.      
  840.      void
  841.      glibtop_get_proc_uid_l (glibtop *server, glibtop_proc_uid *buf,
  842.                              pid_t pid);
  843.  
  844.    Declaration of `glibtop_proc_uid' in `<glibtop/procuid.h>':
  845.  
  846.      typedef struct _glibtop_proc_uid        glibtop_proc_uid;
  847.      
  848.      struct _glibtop_proc_uid
  849.      {
  850.          u_int64_t flags;
  851.          int uid,
  852.              euid,
  853.              gid,
  854.              egid,
  855.              suid,
  856.              sgid,
  857.              fsuid,
  858.              fsgid,
  859.              pid,
  860.              ppid,
  861.              pgrp,
  862.              session,
  863.              tty,
  864.              tpgid,
  865.              priority,
  866.              nice,
  867.              ngroups,
  868.              groups [GLIBTOP_MAX_GROUPS];
  869.      };
  870.  
  871. `uid'
  872.      User ID
  873.  
  874. `euid'
  875.      Effective User ID
  876.  
  877. `gid'
  878.      Group ID
  879.  
  880. `egid'
  881.      Effective Group ID
  882.  
  883. `pid'
  884.      Process ID
  885.  
  886. `ppid'
  887.      PID of parent process
  888.  
  889. `pgrp'
  890.      Process group ID
  891.  
  892. `session'
  893.      Session ID
  894.  
  895. `tty'
  896.      Full device number of controlling terminal
  897.  
  898. `tpgid'
  899.      Terminal process group ID
  900.  
  901. `priority'
  902.      Kernel scheduling priority.
  903.  
  904. `nice'
  905.      Standard unix nice level of process.
  906.  
  907. `ngroups'
  908.      Number of additional process groups.
  909.  
  910. `groups'
  911.      Array of additional process groups
  912.      (`GLIBTOP_MAX_GROUPS' is defined in `<glibtop/limits.h>').
  913.  
  914. 
  915. File: libgtop.info,  Node: glibtop_proc_mem,  Next: glibtop_proc_time,  Prev: glibtop_proc_uid,  Up: System Dependent
  916.  
  917. Process Memory information
  918. --------------------------
  919.  
  920.    Library function `glibtop_get_proc_mem':
  921.  
  922.      void
  923.      glibtop_get_proc_mem (glibtop_proc_mem *buf, pid_t pid);
  924.      
  925.      void
  926.      glibtop_get_proc_mem_l (glibtop *server, glibtop_proc_mem *buf,
  927.                              pid_t pid);
  928.  
  929.    Declaration of `glibtop_proc_mem' in `<glibtop/procmem.h>':
  930.  
  931.      typedef struct _glibtop_proc_mem        glibtop_proc_mem;
  932.      
  933.      struct _glibtop_proc_mem
  934.      {
  935.          u_int64_t   flags,
  936.              size,
  937.              vsize,
  938.              resident,
  939.              share,
  940.              rss,
  941.              rss_rlim;
  942.      };
  943.  
  944. `size'
  945.      Total number of pages of memory.
  946.  
  947. `vsize'
  948.      Number of pages of virtual memory.
  949.  
  950. `resident'
  951.      Number of residnet set (non-swapped) pages.
  952.  
  953. `share'
  954.      Number of pages of shared (mmap'd) memory.
  955.  
  956. `rss'
  957.      Number of pages the process has in real memory, minus 3 for
  958.      administrative purposes.
  959.  
  960.      This is just the pages which count towards text, data, or stack
  961.      space.  This does not include pages which have not been
  962.      demand-loaded in, or which are swapped out.
  963.  
  964. `rss_rlim'
  965.      Current limit in bytes on the rss of the process (usually
  966.      2,147,483,647).
  967.  
  968.    The description above is taken from the manual page of the `/proc'
  969. filesystem under Linux and is a little bit confusing, so I make this
  970. clear here.
  971.  
  972.    *Note for people porting LibGTop to other systems:* Every operating
  973. system has its own idea about the memory usage of a process and also
  974. system utilities like `ps' show different things on different systems.
  975.  
  976.    Nevertheless, we should try to make LibGTop as system independent as
  977. possible, so I give you some hints here how `glibtop_get_proc_mem'
  978. should work.
  979.  
  980.    * When you use `mmap' with either `MAP_SHARED' or `MAP_PRIVATE',
  981.      this should only affect the `vsize' of the process and none of its
  982.      `size', `resident', `shared' and `rss' sizes.
  983.  
  984.    * As soon as you read some of the `mmap()'ed pages, they will be
  985.      demand- oaded and thus count towards the `size' of the process.
  986.  
  987.      Also - we assume there is enough free memory - they are resident
  988.      in memory until they get stolen or swapped out and thus increase
  989.      the `resident' and `rss' sizes of the process.
  990.  
  991.    * If the process has used `MAP_SHARED' and another process attaches
  992.      the same file also `MAP_SHARED', some of the pages are shared with
  993.      this process and thus increase the `shared' sizes of both
  994.      processes.
  995.  
  996.    * If the process has used `MAP_PRIVATE' and writes to the `mmap()'ed
  997.      pages, the only difference to reading from them is that they get
  998.      dirty and cannot be stolen any longer but will get swapped out.
  999.  
  1000.    * When memory gets rare, clean pages are normally stolen, which
  1001.      decreases the `size', `resident', `shared' and `rss' sizes of the
  1002.      process.
  1003.  
  1004.    * When dirty pages are swapped out, this will not decrease the
  1005.      `size' of the process but only its `resident' and `rss' sizes
  1006.      (dirty pages cannot be shared).
  1007.  
  1008.    * The `vsize' of a process can _only_ be changed by the process
  1009.      itself when it requests or frees memory but _never_ due to swapping
  1010.      activity of the system.
  1011.  
  1012.    * If the `shared' size changes, this _only_ means that the number of
  1013.      pages that are currently shared with other processes has changed;
  1014.      if this happens, this will _never_ affect any of the other sizes
  1015.      of the process.
  1016.  
  1017.    The hints above describe how it works under Linux - but we should
  1018. try to make `glibtop_get_proc_mem' show the same behavior under every
  1019. other system.
  1020.  
  1021. 
  1022. File: libgtop.info,  Node: glibtop_proc_time,  Next: glibtop_proc_signal,  Prev: glibtop_proc_mem,  Up: System Dependent
  1023.  
  1024. Process Time information
  1025. ------------------------
  1026.  
  1027.    Library function `glibtop_get_proc_time':
  1028.  
  1029.      void
  1030.      glibtop_get_proc_time (glibtop_proc_time *buf, pid_t pid);
  1031.      
  1032.      void
  1033.      glibtop_get_proc_time_l (glibtop *server, glibtop_proc_time *buf,
  1034.                               pid_t pid);
  1035.  
  1036.    Declaration of `glibtop_proc_time' in `<glibtop/proctime.h>':
  1037.  
  1038.      typedef struct _glibtop_proc_time       glibtop_proc_time;
  1039.      
  1040.      struct _glibtop_proc_time
  1041.      {
  1042.          u_int64_t   flags,
  1043.              start_time,
  1044.              rtime,
  1045.              utime,
  1046.              stime,
  1047.              cutime,
  1048.              cstime,
  1049.              timeout,
  1050.              it_real_value,
  1051.              frequency,
  1052.              xcpu_utime [GLIBTOP_NCPU],
  1053.              xcpu_stime [GLIBTOP_NCPU],
  1054.              xcpu_flags;
  1055.      };
  1056.  
  1057. `start_time'
  1058.      Start time of process in seconds since the epoch
  1059.  
  1060. `rtime'
  1061.      Real time accumulated by process (should be `utime' + `stime')
  1062.  
  1063. `utime'
  1064.      User-mode CPU time accumulated by process
  1065.  
  1066. `stime'
  1067.      Kernel-mode CPU time accumulated by process
  1068.  
  1069. `cutime'
  1070.      Cumulative utime of process and reaped children
  1071.  
  1072. `cstime'
  1073.      Cumulative stime of process and reaped children
  1074.  
  1075. `timeout'
  1076.      The time (in jiffies) of the process's next timeout
  1077.  
  1078. `it_real_value'
  1079.      The time (in jiffies) before the next SIGALRM is sent to the
  1080.      process due to an interval timer.
  1081.  
  1082. `frequency'
  1083.      Tick frequency
  1084.  
  1085. `xcpu_utime'
  1086.      SMP user-mode CPU time accumulated by process
  1087.  
  1088. `xcpu_stime'
  1089.      SMP kernel-mode CPU time accumulated by process
  1090.  
  1091. 
  1092. File: libgtop.info,  Node: glibtop_proc_signal,  Next: glibtop_proc_kernel,  Prev: glibtop_proc_time,  Up: System Dependent
  1093.  
  1094. Process Signal information
  1095. --------------------------
  1096.  
  1097.    Library function `glibtop_get_proc_signal':
  1098.  
  1099.      void
  1100.      glibtop_get_proc_signal (glibtop_proc_signal *buf, pid_t pid);
  1101.      
  1102.      void
  1103.      glibtop_get_proc_signal_l (glibtop *server, glibtop_proc_signal *buf,
  1104.                                 pid_t pid);
  1105.  
  1106.    Declaration of `glibtop_proc_signal' in `<glibtop/procsignal.h>':
  1107.  
  1108.      typedef struct _glibtop_proc_signal     glibtop_proc_signal;
  1109.      
  1110.      struct _glibtop_proc_signal
  1111.      {
  1112.          u_int64_t   flags,
  1113.              signal [2],
  1114.              blocked [2],
  1115.              sigignore [2],
  1116.              sigcatch [2];
  1117.      };
  1118.  
  1119. `signal'
  1120.      Mask of pending signals
  1121.  
  1122. `blocked'
  1123.      Mask of blocked signals
  1124.  
  1125. `sigignore'
  1126.      Mask of ignored signals
  1127.  
  1128. `sigcatch'
  1129.      Mask of caught signals
  1130.  
  1131.    All signal masks are interpreted as bit mask; it is an array of two
  1132. `u_int64_t''s so we can save 128 signals there.
  1133.  
  1134. 
  1135. File: libgtop.info,  Node: glibtop_proc_kernel,  Next: glibtop_proc_segment,  Prev: glibtop_proc_signal,  Up: System Dependent
  1136.  
  1137. Process Kernel Data information
  1138. -------------------------------
  1139.  
  1140.    Library function `glibtop_get_proc_kernel':
  1141.  
  1142.      void
  1143.      glibtop_get_proc_kernel (glibtop_proc_kernel *buf, pid_t pid);
  1144.      
  1145.      void
  1146.      glibtop_get_proc_kernel_l (glibtop *server, glibtop_proc_kernel *buf,
  1147.                                 pid_t pid);
  1148.  
  1149.    Declaration of `glibtop_proc_kernel' in `<glibtop/prockernel.h>':
  1150.  
  1151.      typedef struct _glibtop_proc_kernel     glibtop_proc_kernel;
  1152.      
  1153.      struct _glibtop_proc_kernel
  1154.      {
  1155.          u_int64_t flags;
  1156.          u_int64_t k_flags,
  1157.              min_flt,
  1158.              maj_flt,
  1159.              cmin_flt,
  1160.              cmaj_flt,
  1161.              kstk_esp,
  1162.              kstk_eip,
  1163.              nwchan;
  1164.          char wchan [40];
  1165.      };
  1166.  
  1167. `k_flags'
  1168.      Kernel flags of the process. See the constants defined below.
  1169.  
  1170. `min_flt'
  1171.      The number of minor faults the process has made, those which have
  1172.      not required loading a memory page from disk.
  1173.  
  1174. `maj_flt'
  1175.      The number of major faults the process has made, those which have
  1176.      required loading a memory page from disk.
  1177.  
  1178. `cmin_flt'
  1179.      The number of minor faults that the process and its children have
  1180.      made.
  1181.  
  1182. `cmaj_flt'
  1183.      The number of major faults that the process and its children have
  1184.      made.
  1185.  
  1186. `kstk_esp'
  1187.      The current value of `esp' (32-bit stack pointer), as found in the
  1188.      kernel stack page for the process.
  1189.  
  1190. `kstk_eip'
  1191.      The current `eip' (32-bit instruction pointer).
  1192.  
  1193. `nwchan'
  1194.      This is the "channel" in which the process is waiting. This is the
  1195.      address of a system call, and can be looked up in a namelist if
  1196.      you need a textual name.  (If you have an up-to-date
  1197.      `/etc/psdatabase', then try `ps -l' to see the WCHAN field in
  1198.      action).
  1199.  
  1200. `wchan'
  1201.      This is the textual name of the `nwchan' field.
  1202.  
  1203.    There are some constants for the `k_flags' field:
  1204.  
  1205.      #define GLIBTOP_KFLAGS_STARTING         1
  1206.      #define GLIBTOP_KFLAGS_EXITING          2
  1207.      #define GLIBTOP_KFLAGS_PTRACED          4
  1208.      #define GLIBTOP_KFLAGS_TRACESYS         8
  1209.      #define GLIBTOP_KFLAGS_FORKNOEXEC       16
  1210.      #define GLIBTOP_KFLAGS_SUPERPRIV        32
  1211.      #define GLIBTOP_KFLAGS_DUMPEDCORE       64
  1212.      #define GLIBTOP_KFLAGS_SIGNALED         128
  1213.  
  1214. `GLIBTOP_KFLAGS_STARTING'
  1215.      Process is being created.
  1216.  
  1217. `GLIBTOP_KFLAGS_EXITING'
  1218.      Process is exiting.
  1219.  
  1220. `GLIBTOP_KFLAGS_PTRACED'
  1221.      Process is being traced (via `ptrace ()').
  1222.  
  1223. `GLIBTOP_KFLAGS_TRACESYS'
  1224.      Process is tracing system calls.
  1225.  
  1226. `GLIBTOP_KFLAGS_FORKNOEXEC'
  1227.      Process `fork()'ed, but didn't `exec()' yet.
  1228.  
  1229. `GLIBTOP_KFLAGS_SUPERPRIV'
  1230.      Process used super-user privileges.
  1231.  
  1232. `GLIBTOP_KFLAGS_DUMPEDCORE'
  1233.      Process dumped core.
  1234.  
  1235. `GLIBTOP_KFLAGS_SIGNALED'
  1236.      Process was killed by a signal.
  1237.  
  1238. 
  1239. File: libgtop.info,  Node: glibtop_proc_segment,  Next: glibtop_proc_args,  Prev: glibtop_proc_kernel,  Up: System Dependent
  1240.  
  1241. Process Segment information
  1242. ---------------------------
  1243.  
  1244.    Library function `glibtop_get_proc_segment':
  1245.  
  1246.      void
  1247.      glibtop_get_proc_segment (glibtop_proc_segment *buf, pid_t pid);
  1248.      
  1249.      void
  1250.      glibtop_get_proc_segment_l (glibtop *server, glibtop_proc_segment *buf,
  1251.                                  pid_t pid);
  1252.  
  1253.    Declaration of `glibtop_proc_segment' in `<glibtop/procsegment.h>':
  1254.  
  1255.      typedef struct _glibtop_proc_segment    glibtop_proc_segment;
  1256.      
  1257.      struct _glibtop_proc_segment
  1258.      {
  1259.          u_int64_t   flags,
  1260.              text_rss,
  1261.              shlib_rss,
  1262.              data_rss,
  1263.              stack_rss,
  1264.              dirty_size,
  1265.              start_code,
  1266.              end_code,
  1267.              start_data,
  1268.              end_data,
  1269.              start_brk,
  1270.              end_brk,
  1271.              start_stack,
  1272.              start_mmap,
  1273.              arg_start,
  1274.              arg_end,
  1275.              env_start,
  1276.              env_end;
  1277.      };
  1278.  
  1279. `text_rss'
  1280.      Text resident set size
  1281.  
  1282. `shlib_rss'
  1283.      Shared-Lib resident set size
  1284.  
  1285. `data_rss'
  1286.      Data resident set size
  1287.  
  1288. `stack_rss'
  1289.      Stack resident set size
  1290.  
  1291. `dirty_size'
  1292.      Total size of dirty pages
  1293.  
  1294. `start_code'
  1295.      Address of beginning of code segment
  1296.  
  1297. `end_code'
  1298.      Address of end of code segment
  1299.  
  1300. `start_stack'
  1301.      Address of the bottom of stack segmen
  1302.  
  1303. 
  1304. File: libgtop.info,  Node: glibtop_proc_args,  Next: glibtop_proc_map,  Prev: glibtop_proc_segment,  Up: System Dependent
  1305.  
  1306. Process Arguments
  1307. -----------------
  1308.  
  1309.    Library function `glibtop_get_proc_args':
  1310.  
  1311.      char *
  1312.      glibtop_get_proc_args_l (glibtop_proc_args *buf, pid_t pid,
  1313.                               unsigned max_len);
  1314.      
  1315.      char *
  1316.      glibtop_get_proc_args_l (glibtop *server, glibtop_proc_args *buf,
  1317.                               pid_t pid, unsigned max_len);
  1318.  
  1319.    Declaration of `glibtop_proc_args' in `<glibtop/procargs.h>':
  1320.  
  1321.      typedef struct _glibtop_proc_args       glibtop_proc_args;
  1322.      
  1323.      struct _glibtop_proc_args
  1324.      {
  1325.          u_int64_t   flags,
  1326.              size;
  1327.      };
  1328.  
  1329.    Returns a string with all command line arguments of process `pid'
  1330. (up to `max_len' characters, use zero to get all arguments).
  1331.  
  1332.    The command line arguments in the returned string are separated by
  1333. zero bytes; the lenght of this string is returned in the `size' field.
  1334.  
  1335.    Remember to `glibtop_free' the returned string to avoid a memory
  1336. leak.
  1337.  
  1338. 
  1339. File: libgtop.info,  Node: glibtop_proc_map,  Next: glibtop_netload,  Prev: glibtop_proc_args,  Up: System Dependent
  1340.  
  1341. Process Memory Maps
  1342. -------------------
  1343.  
  1344.    Library function `glibtop_get_proc_map':
  1345.  
  1346.      glibtop_map_entry *
  1347.      glibtop_get_proc_map (glibtop_proc_map *buf, pid_t pid);
  1348.      
  1349.      glibtop_map_entry *
  1350.      glibtop_get_proc_map_l (glibtop *server, glibtop_proc_map *buf,
  1351.                              pid_t pid);
  1352.  
  1353.    Declaration of `glibtop_proc_map' in `<glibtop/procmap.h>':
  1354.  
  1355.      typedef struct _glibtop_proc_map        glibtop_proc_map;
  1356.      
  1357.      struct _glibtop_proc_map
  1358.      {
  1359.          u_int64_t   flags,
  1360.              number,
  1361.              total,
  1362.              size;
  1363.      };
  1364.  
  1365.    Returns a `glibtop_map_entry *' list (which needs to be freed with
  1366. `glibtop_free') of memory maps of process `pid'.
  1367.  
  1368. `number'
  1369.      Number of entries in the returned list.
  1370.  
  1371. `total'
  1372.      Total size of the returned list (this equals `number * size').
  1373.  
  1374. `size'
  1375.      Size of a single entry in the returned list (this equals `sizeof
  1376.      (glibtop_map_entry)').
  1377.  
  1378.      typedef struct _glibtop_map_entry       glibtop_map_entry;
  1379.      
  1380.      struct _glibtop_map_entry
  1381.      {
  1382.          u_int64_t flags, start, end, offset, perm, inode, device;
  1383.          char filename [GLIBTOP_MAP_FILENAME_LEN+1];
  1384.      };
  1385.  
  1386.    The `flags' member is a bit field and specifies which of the other
  1387. fields are valid:
  1388.  
  1389.      #define GLIBTOP_MAP_ENTRY_START         1
  1390.      #define GLIBTOP_MAP_ENTRY_END           2
  1391.      #define GLIBTOP_MAP_ENTRY_OFFSET        3
  1392.      #define GLIBTOP_MAP_ENTRY_PERM          4
  1393.      #define GLIBTOP_MAP_ENTRY_INODE         5
  1394.      #define GLIBTOP_MAP_ENTRY_DEVICE        6
  1395.      #define GLIBTOP_MAP_ENTRY_FILENAME      7
  1396.  
  1397.    Constants for the `perm' member:
  1398.  
  1399.      #define GLIBTOP_MAP_PERM_READ           1
  1400.      #define GLIBTOP_MAP_PERM_WRITE          2
  1401.      #define GLIBTOP_MAP_PERM_EXECUTE        4
  1402.      #define GLIBTOP_MAP_PERM_SHARED         8
  1403.      #define GLIBTOP_MAP_PERM_PRIVATE        16
  1404.  
  1405. 
  1406. File: libgtop.info,  Node: glibtop_netload,  Next: glibtop_ppp,  Prev: glibtop_proc_map,  Up: System Dependent
  1407.  
  1408. Network Load
  1409. ------------
  1410.  
  1411.    Library function `glibtop_get_netload':
  1412.  
  1413.      void
  1414.      glibtop_get_netload (glibtop_netload *buf, const char *interface);
  1415.      
  1416.      void
  1417.      glibtop_get_netload_l (glibtop *server, glibtop_netload *buf,
  1418.                             const char *interface);
  1419.  
  1420.    Declaration of `glibtop_netload' in `<glibtop/netload.h>':
  1421.  
  1422.      typedef struct _glibtop_netload glibtop_netload;
  1423.      
  1424.      struct _glibtop_netload
  1425.      {
  1426.          u_int64_t   flags,
  1427.              if_flags,
  1428.              mtu,
  1429.              subnet,
  1430.              address,
  1431.              packets_in,
  1432.              packets_out,
  1433.              packets_total,
  1434.              bytes_in,
  1435.              bytes_out,
  1436.              bytes_total,
  1437.              errors_in,
  1438.              errors_out,
  1439.              errors_total,
  1440.              collisions;
  1441.      };
  1442.  
  1443.    Returns network statistics for interface `interface' (which is the
  1444. same than in `ifconfig').
  1445.  
  1446. `if_flags'
  1447.      Interface flags. See the contants defined below.
  1448.  
  1449. `mtu'
  1450.      Maximum Transfer Unit (MTU)
  1451.  
  1452. `subnet'
  1453.      Subnet Address
  1454.  
  1455. `address'
  1456.      Interface Address
  1457.  
  1458. `packets_in'
  1459.      Total number of incoming packets
  1460.  
  1461. `packets_out'
  1462.      Total number of outgoing packets
  1463.  
  1464. `packets_total'
  1465.      Total number of packets
  1466.  
  1467. `bytes_in'
  1468.      Total number of incoming bytes
  1469.  
  1470. `bytes_out'
  1471.      Total number of outgoing bytes
  1472.  
  1473. `bytes_total'
  1474.      Total number of bytes
  1475.  
  1476. `errors_in'
  1477.      Total number of errors in incoming direction
  1478.  
  1479. `errors_out'
  1480.      Total number of errors in outgoing direction
  1481.  
  1482. `errors_total'
  1483.      Total number of errors
  1484.  
  1485. `collisions'
  1486.      Total number of collisions
  1487.  
  1488.    Please note that not all operating systems distinguish between
  1489. incoming/outgoing bytes/packets/errors - in this case only the `_total'
  1490. fields are valid.  Otherwise, they're just `_in' plus `_out'.
  1491.  
  1492.    Constants for `if_flags':
  1493.  
  1494.      enum {
  1495.          GLIBTOP_IF_FLAGS_UP = 1,
  1496.          GLIBTOP_IF_FLAGS_BROADCAST,
  1497.          GLIBTOP_IF_FLAGS_DEBUG,
  1498.          GLIBTOP_IF_FLAGS_LOOPBACK,
  1499.          GLIBTOP_IF_FLAGS_POINTOPOINT,
  1500.          GLIBTOP_IF_FLAGS_RUNNING,
  1501.          GLIBTOP_IF_FLAGS_NOARP,
  1502.          GLIBTOP_IF_FLAGS_PROMISC,
  1503.          GLIBTOP_IF_FLAGS_ALLMULTI,
  1504.          GLIBTOP_IF_FLAGS_OACTIVE,
  1505.          GLIBTOP_IF_FLAGS_SIMPLEX,
  1506.          GLIBTOP_IF_FLAGS_LINK0,
  1507.          GLIBTOP_IF_FLAGS_LINK1,
  1508.          GLIBTOP_IF_FLAGS_LINK2,
  1509.          GLIBTOP_IF_FLAGS_ALTPHYS,
  1510.          GLIBTOP_IF_FLAGS_MULTICAST
  1511.      };
  1512.  
  1513. 
  1514. File: libgtop.info,  Node: glibtop_ppp,  Prev: glibtop_netload,  Up: System Dependent
  1515.  
  1516. PPP Statistics
  1517. --------------
  1518.  
  1519.    Library function `glibtop_get_ppp':
  1520.  
  1521.      void
  1522.      glibtop_get_ppp_l (glibtop *server, glibtop_ppp *buf,
  1523.                         unsigned short device);
  1524.      
  1525.      void
  1526.      glibtop_get_ppp (glibtop_ppp *buf, unsigned short device);
  1527.  
  1528.    Declaration of `glibtop_ppp' in `<glibtop/ppp.h>':
  1529.  
  1530.      typedef struct _glibtop_ppp     glibtop_ppp;
  1531.      
  1532.      struct _glibtop_ppp
  1533.      {
  1534.          u_int64_t   flags,
  1535.              state,
  1536.              bytes_in,
  1537.              bytes_out;
  1538.      };
  1539.  
  1540. `bytes_in'
  1541.      Number of input bytes
  1542.  
  1543. `bytes_out'
  1544.      Number of output bytes
  1545.  
  1546.    There are some constants for `state':
  1547.  
  1548.      enum {
  1549.          GLIBTOP_PPP_STATE_UNKNOWN = 0,
  1550.          GLIBTOP_PPP_STATE_HANGUP,
  1551.          GLIBTOP_PPP_STATE_ONLINE
  1552.      };
  1553.  
  1554. `GLIBTOP_PPP_STATE_UNKNOWN'
  1555.      LibGTop was unable to determine the current ppp state.
  1556.  
  1557. `GLIBTOP_PPP_STATE_HANGUP'
  1558.      We're currently offline.
  1559.  
  1560. `GLIBTOP_PPP_STATE_ONLINE'
  1561.      We're currently online.
  1562.  
  1563. 
  1564. File: libgtop.info,  Node: Common Functions,  Next: Library Functions,  Prev: System Dependent,  Up: Reference Manual
  1565.  
  1566. Common Functions
  1567. ================
  1568.  
  1569.    This are functions which a common implementation for all systems; we
  1570. never use the server for them.
  1571.  
  1572.    The file system code is taken from GNU Fileutils.
  1573.  
  1574. * Menu:
  1575.  
  1576. * glibtop_mountlist::           Mount List.
  1577. * glibtop_fsusage::             File System Usage.
  1578.  
  1579. 
  1580. File: libgtop.info,  Node: glibtop_mountlist,  Next: glibtop_fsusage,  Prev: Common Functions,  Up: Common Functions
  1581.  
  1582. Mount List
  1583. ----------
  1584.  
  1585.    Library function `glibtop_get_mountlist':
  1586.  
  1587.      glibtop_mountentry *
  1588.      glibtop_get_mountlist_l (glibtop *server, glibtop_mountlist *buf,
  1589.                               int all_fs);
  1590.      
  1591.      glibtop_mountentry *
  1592.      glibtop_get_mountlist (glibtop_mountlist *buf, int all_fs);
  1593.  
  1594.    The `all_fs' parameter specifies whether information about all
  1595. filesystems should be returned; this will include filesystem types like
  1596. `autofs' and `procfs'. You should not use this in disk usage programs,
  1597. but it can be useful to get a list of all currently mounted filesystems.
  1598.  
  1599.    Declaration of `glibtop_proc_map' in `<glibtop/procmap.h>':
  1600.  
  1601.      typedef struct _glibtop_mountlist       glibtop_mountlist;
  1602.      
  1603.      struct _glibtop_mountlist
  1604.      {
  1605.          u_int64_t   flags,
  1606.              number,
  1607.              total,
  1608.              size;
  1609.      };
  1610.  
  1611.    Returns a `glibtop_mountentry *' list (which needs to be freed with
  1612. `glibtop_free') of mounted filesystems.
  1613.  
  1614. `number'
  1615.      Number of entries in the returned list.
  1616.  
  1617. `total'
  1618.      Total size of the returned list (this equals `number * size').
  1619.  
  1620. `size'
  1621.      Size of a single entry in the returned list (this equals `sizeof
  1622.      (glibtop_mountentry)').
  1623.  
  1624.      typedef struct _glibtop_mountentry      glibtop_mountentry;
  1625.      
  1626.      struct _glibtop_mountentry
  1627.      {
  1628.          u_int64_t dev;
  1629.          char devname [GLIBTOP_MOUNTENTRY_LEN+1];
  1630.          char mountdir [GLIBTOP_MOUNTENTRY_LEN+1];
  1631.          char type [GLIBTOP_MOUNTENTRY_LEN+1];
  1632.      };
  1633.  
  1634.    `GLIBTOP_MOUNTENTRY_LEN' is defined in `<glibtop.h>' (this was moved
  1635. to `<glibtop/limits.h>' in LibGTop 1.1.0).
  1636.  
  1637. `devname'
  1638.      Full pathname (such as `/dev/sdb1' for instance) to the mounted
  1639.      device.
  1640.  
  1641. `mountdir'
  1642.      Full pathname of the mountpoint (such as `/usr/local' for
  1643.      instance).
  1644.  
  1645. `type'
  1646.      Filesystem type as a textual string (such as `ext2fs').
  1647.  
  1648. 
  1649. File: libgtop.info,  Node: glibtop_fsusage,  Prev: glibtop_mountlist,  Up: Common Functions
  1650.  
  1651. File System Usage
  1652. -----------------
  1653.  
  1654.    Library function `glibtop_get_fsusage':
  1655.  
  1656.      void
  1657.      glibtop_get_fsusage_l (glibtop *server, glibtop_fsusage *buf,
  1658.                             const char *mount_dir);
  1659.      
  1660.      void
  1661.      glibtop_get_fsusage (glibtop_fsusage *buf, const char *mount_dir);
  1662.  
  1663.    Declaration of `glibtop_fsusage' in `<glibtop/fsusage.h>':
  1664.  
  1665.      typedef struct _glibtop_fsusage         glibtop_fsusage;
  1666.      
  1667.      struct _glibtop_fsusage
  1668.      {
  1669.          u_int64_t   flags,
  1670.              blocks,
  1671.              bfree,
  1672.              bavail,
  1673.              files,
  1674.              ffree;
  1675.      };
  1676.  
  1677. `blocks'
  1678.      Total blocks in the filesystem.
  1679.  
  1680. `bfree'
  1681.      Free blocks available to the superuser.
  1682.  
  1683. `bavail'
  1684.      Free blocks available to ordinary users.
  1685.  
  1686. `files'
  1687.      Total file nodes.
  1688.  
  1689. `ffree'
  1690.      Free file nodes.
  1691.  
  1692.    Blocks are usually 512 bytes.
  1693.  
  1694. 
  1695. File: libgtop.info,  Node: Library Functions,  Prev: Common Functions,  Up: Reference Manual
  1696.  
  1697. Library Functions
  1698. =================
  1699.  
  1700.    This are general library functions which can be used to get
  1701. information about the library and to control its behavior.
  1702.  
  1703. * Menu:
  1704.  
  1705. * glibtop_init::                Server Initialization.
  1706. * glibtop_sysdeps::             Server Sysdeps.
  1707. * Library Parameters::          Library Parameters.
  1708.  
  1709. 
  1710. File: libgtop.info,  Node: glibtop_init,  Next: glibtop_sysdeps,  Prev: Library Functions,  Up: Library Functions
  1711.  
  1712. Server Initialization
  1713. ---------------------
  1714.  
  1715.    You do not need to worry about the `glibtop *' server structure if
  1716. you don't need - the library exports a `glibtop_global_server' which
  1717. you can use everywhere a `glibtop *' is expected.
  1718.  
  1719.    Most of the library and all of the sysdeps function also have an
  1720. alias (which is the function name without the `_l', `_s' or `_r'
  1721. suffix) which don't take a `glibtop *' as argument but uses the
  1722. `glibtop_global_server' instead.
  1723.  
  1724.      extern glibtop *glibtop_global_server;
  1725.  
  1726.    Library function `glibtop_init':
  1727.  
  1728.      glibtop *
  1729.      glibtop_init_r (glibtop **server_ptr, unsigned long features,
  1730.                      unsigned flags);
  1731.      
  1732.      void
  1733.      glibtop_init (void);
  1734.  
  1735.    This function initializes a LibGTop server. It is automatically
  1736. called when you use any of the LibGTop functions and will use the
  1737. global server in this case.
  1738.  
  1739.    However, it's appreciated to call `glibtop_init' during the
  1740. initialization of your application.
  1741.  
  1742.    You can for instance use
  1743.  
  1744.      glibtop_init ();
  1745.  
  1746. which is equivalent to
  1747.  
  1748.      glibtop_init_r (&glibtop_global_server, 0, 0);
  1749.  
  1750.    Please note that the `server_ptr' argument is a pointer to a pointer
  1751. (and thus is of type `glibtop **').
  1752.  
  1753.    To control what `glibtop_init' should actually do, you can use the
  1754. `features' and `flags' arguments.
  1755.  
  1756.    The `features' argument is a bit-mask (interpreted in the same way
  1757. than `sysdeps.features') and tells the library which features you're
  1758. interested in. The library will only start the server if this is
  1759. required for any of those features.
  1760.  
  1761.    You can use the following constants for the `flags' parameter to
  1762. control the behavior of the library:
  1763.  
  1764. `GLIBTOP_INIT_NO_INIT'
  1765.      Tells the library to do nothing. If the value pointed to by the
  1766.      `server_ptr' argument is `NULL', it will set it to the
  1767.      `glibtop_global_server' and then return.
  1768.  
  1769. `GLIBTOP_INIT_NO_OPEN'
  1770.      Do the initialization, but do not start the server.
  1771.  
  1772.    To modify the way the `features' are interpretet, you can use the
  1773. following constants for `flags' (as a bit mask):
  1774.  
  1775. `GLIBTOP_FEATURES_NO_SERVER'
  1776.      Never use the server, always call the sysdeps code directly.  If
  1777.      you require any privileges to get them and you don't have those
  1778.      privileges, the this will obviously not work and the library will
  1779.      fail to return some or all of the requested values.
  1780.  
  1781. `GLIBTOP_FEATURES_EXCEPT'
  1782.      Inverts the matching of the `features' parameter, i.e. if you use
  1783.      this flag this means that `features' are all the features you are
  1784.      _not_ interested in.  Might be useful to say something like "I
  1785.      want everything but ppp".
  1786.  
  1787. 
  1788. File: libgtop.info,  Node: glibtop_sysdeps,  Next: Library Parameters,  Prev: glibtop_init,  Up: Library Functions
  1789.  
  1790. Server Sysdeps
  1791. --------------
  1792.  
  1793.    Library function `glibtop_get_sysdeps':
  1794.  
  1795.      void
  1796.      glibtop_get_sysdeps_r (glibtop *server, glibtop_sysdeps *buf);
  1797.      
  1798.      void
  1799.      glibtop_get_sysdeps (glibtop_sysdeps *buf);
  1800.  
  1801.    Declaration of `glibtop_sysdeps' in `<glibtop/sysdeps.h>':
  1802.  
  1803.      typedef struct _glibtop_sysdeps         glibtop_sysdeps;
  1804.      
  1805.      struct _glibtop_sysdeps
  1806.      {
  1807.          u_int64_t flags,
  1808.              features,
  1809.              pointer_size,
  1810.              cpu,
  1811.              mem,
  1812.              swap,
  1813.              uptime,
  1814.              loadavg,
  1815.              shm_limits,
  1816.              msg_limits,
  1817.              sem_limits,
  1818.              proclist,
  1819.              proc_state,
  1820.              proc_uid,
  1821.              proc_mem,
  1822.              proc_time,
  1823.              proc_signal,
  1824.              proc_kernel,
  1825.              proc_segment,
  1826.              proc_args,
  1827.              proc_map,
  1828.              mountlist,
  1829.              fsusage,
  1830.              netload,
  1831.              ppp;
  1832.      };
  1833.  
  1834. `features'
  1835.      This is a bit field (the so-called "server features") stating for
  1836.      which features we need to use the server.
  1837.  
  1838. `pointer_size'
  1839.      This was added in LibGTop 1.1.0 and tells you the number of bits a
  1840.      `void*' has in the server (this may be different from the size on
  1841.      the client machine if we're talking over the daemon to a remove
  1842.      machine).
  1843.  
  1844.    The following constants from `<glibtop/sysdeps.h>' serve as
  1845. bit-indices for the `features' field:
  1846.  
  1847.      #define GLIBTOP_SYSDEPS_CPU             0
  1848.      #define GLIBTOP_SYSDEPS_MEM             1
  1849.      #define GLIBTOP_SYSDEPS_SWAP            2
  1850.      #define GLIBTOP_SYSDEPS_UPTIME          3
  1851.      #define GLIBTOP_SYSDEPS_LOADAVG         4
  1852.      #define GLIBTOP_SYSDEPS_SHM_LIMITS      5
  1853.      #define GLIBTOP_SYSDEPS_MSG_LIMITS      6
  1854.      #define GLIBTOP_SYSDEPS_SEM_LIMITS      7
  1855.      #define GLIBTOP_SYSDEPS_PROCLIST        8
  1856.      #define GLIBTOP_SYSDEPS_PROC_STATE      9
  1857.      #define GLIBTOP_SYSDEPS_PROC_UID        10
  1858.      #define GLIBTOP_SYSDEPS_PROC_MEM        11
  1859.      #define GLIBTOP_SYSDEPS_PROC_TIME       12
  1860.      #define GLIBTOP_SYSDEPS_PROC_SIGNAL     13
  1861.      #define GLIBTOP_SYSDEPS_PROC_KERNEL     14
  1862.      #define GLIBTOP_SYSDEPS_PROC_SEGMENT    15
  1863.      #define GLIBTOP_SYSDEPS_PROC_ARGS       16
  1864.      #define GLIBTOP_SYSDEPS_PROC_MAP        17
  1865.      #define GLIBTOP_SYSDEPS_MOUNTLIST       18
  1866.      #define GLIBTOP_SYSDEPS_FSUSAGE         19
  1867.      #define GLIBTOP_SYSDEPS_NETLOAD         20
  1868.      #define GLIBTOP_SYSDEPS_PPP             21
  1869.  
  1870. 
  1871. File: libgtop.info,  Node: Library Parameters,  Prev: glibtop_sysdeps,  Up: Library Functions
  1872.  
  1873. Library Parameters
  1874. ------------------
  1875.  
  1876.    Library function `glibtop_get_parameter':
  1877.  
  1878.      size_t
  1879.      glibtop_get_parameter_l (glibtop *server, const unsigned parameter,
  1880.                               void *data_ptr, size_t data_size);
  1881.      
  1882.      size_t
  1883.      glibtop_get_parameter (const unsigned parameter, void *data_ptr,
  1884.                             size_t data_size);
  1885.  
  1886.    This function is used to retrieve a library parameter (see below for
  1887. a more detailed description). It returns the size of the retrieved
  1888. parameter on success, zero on failure or minus the actual size of the
  1889. parameter if `data_size' was too small.
  1890.  
  1891.    You may call this function with `data_ptr' set to `NULL' to get the
  1892. actual size of a parameter (as a negative value).
  1893.  
  1894. `parameter'
  1895.      The parameter you want to retrieve (see below for constants).
  1896.  
  1897. `data_ptr'
  1898.      Pointer to a place where the parameter should be stored.
  1899.  
  1900. `data_size'
  1901.      Maximum size of the parameter.
  1902.  
  1903.    Library function `glibtop_set_parameter':
  1904.  
  1905.      void
  1906.      glibtop_set_parameter_l (glibtop *server, const unsigned parameter,
  1907.                               const void *data_ptr, size_t data_size);
  1908.      
  1909.      void
  1910.      glibtop_set_parameter (const unsigned parameter, const void *data_ptr,
  1911.                             size_t data_size);
  1912.  
  1913.    This function is used to modify a library parameter. Please not that
  1914. you may not set all parameters since some of them are read-only.
  1915.  
  1916. `parameter'
  1917.      The parameter you want to modify (see below for constants).
  1918.  
  1919. `data_ptr'
  1920.      Pointer to the value which should be set.
  1921.  
  1922. `data_size'
  1923.      Size of the new value. For fixed-size parameters, this must match
  1924.      the exact size of the parameter or you'll get an error.
  1925.  
  1926.    The following parameters are defined in `<glibtop/parameter.h>':
  1927.  
  1928. `GLIBTOP_PARAM_FEATURES'
  1929.      This is a read-only `unsigned long' representing the `features'
  1930.      field of `glibtop_sysdeps'.
  1931.  
  1932. `GLIBTOP_PARAM_REQUIRED'
  1933.      This is a `glibtop_sysdeps' structure specifying which features the
  1934.      client requires the library return. If it fails to get any of
  1935.      them, you'll get an error.
  1936.  
  1937. `GLIBTOP_PARAM_ERROR_METHOD'
  1938.      This is an `unsigned' telling the library what to do if it fails to
  1939.      get any of the features that are marked as required via the
  1940.      `GLIBTOP_PARAM_REQUIRED' parameter (see below for constants).
  1941.  
  1942.    You can use the following constants for `GLIBTOP_PARAM_ERROR_METHOD'
  1943. (defined in `<glibtop/open.h>'):
  1944.  
  1945. `GLIBTOP_ERROR_METHOD_IGNORE'
  1946.      Ignore the error condition.
  1947.  
  1948. `GLIBTOP_ERROR_METHOD_WARN_ONCE'
  1949.      Warn once about the absense of some of the required features, then
  1950.      modify `GLIBTOP_PARAM_REQUIRED' so that the missing ones are no
  1951.      longer required. This is the prefered value for applications since
  1952.      it'll only print out the warning message once and not each time
  1953.      the library tries to get one of those features.
  1954.  
  1955. `GLIBTOP_ERROR_METHOD_WARN'
  1956.      Warn each time the library fails to get some of the required
  1957.      features.
  1958.  
  1959. `GLIBTOP_ERROR_METHOD_ABORT'
  1960.      Abort if the library fails to get some of the required features.
  1961.      This should not be used by applications.
  1962.  
  1963.  
  1964. 
  1965. Tag Table:
  1966. Node: Top1013
  1967. Node: About3165
  1968. Node: Availability4041
  1969. Node: Supported Platforms4679
  1970. Node: Mailing List6263
  1971. Node: Thanks7029
  1972. Node: White Paper7679
  1973. Node: Introduction7907
  1974. Node: Overview9614
  1975. Node: Interface Design9975
  1976. Node: Server Implementation10989
  1977. Node: Reference Manual11695
  1978. Node: System Dependent11994
  1979. Node: glibtop_cpu13060
  1980. Node: glibtop_mem15011
  1981. Node: glibtop_swap16170
  1982. Node: glibtop_uptime17398
  1983. Node: glibtop_loadavg18691
  1984. Node: glibtop_proclist19696
  1985. Node: glibtop_proc_state22930
  1986. Node: glibtop_proc_uid25512
  1987. Node: glibtop_proc_mem27098
  1988. Node: glibtop_proc_time30797
  1989. Node: glibtop_proc_signal32479
  1990. Node: glibtop_proc_kernel33529
  1991. Node: glibtop_proc_segment36434
  1992. Node: glibtop_proc_args37890
  1993. Node: glibtop_proc_map38952
  1994. Node: glibtop_netload40942
  1995. Node: glibtop_ppp43462
  1996. Node: Common Functions44523
  1997. Node: glibtop_mountlist44942
  1998. Node: glibtop_fsusage46932
  1999. Node: Library Functions47886
  2000. Node: glibtop_init48307
  2001. Node: glibtop_sysdeps51051
  2002. Node: Library Parameters53665
  2003. 
  2004. End Tag Table
  2005.